#include <iostream>
#include<assert.h>
#include<string.h>
using namespace  std;
namespace Wxb
{
    class string
    {
    public:
        typedef char* iterator;
        iterator begin()//头指针
        {
            return _str;
        }

        iterator end()//尾指针
        {
            return _str+_size;//最后一一个数据的下一个位置\0
        }

        string(const char* str = "")//默认构造
                : _str(new char[strlen(str)+1])
                 ,_size(strlen(str))
                 ,_capacity(strlen(str)+1)
        {
            strcpy(_str, str);
        }

        string(const string &s)//拷贝构造
                : _str(NULL)
        {
            string tmp(s._str);
            ::swap(_str, tmp._str);// void::这里代表取全局域中找
            //互相交换他们指向的空间
        }

        string& operator=(string s)//赋值构造
        {
            //资本家看了都落泪，不仅你的是我的，我不要了你还要以为擦屁股
            //string tmp(s._str);
            //::swap(_str,tmp._str);

            ::swap(_str, s._str);
            return *this;
        }
        ~string()//析构
        {
            delete []_str;
            cout<<"free had success";
        }


        //modify
        void push_back(char c)//字符插入
        {
            if(_size>=_capacity-1)
            {
                reserve(_capacity*2);
            }
            _str[_size++]=c;
            _str[_size]='\0';
        }

        void append(const char* str)//字符串插入
        {
            if(_size>=_capacity-1)
            {
                reserve(_capacity+strlen(str));
            }
          while(*str!='\0')
          {
              _str[_size++]=*str++;
          }
            _str[_size]='\0';
        }
        inline void clear()
        {
            _size=0;

        }

        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }
        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }
        void swap(string& s)
        {
            ::swap(_str,s._str);
            ::swap(_size,s._size);
            ::swap(_capacity,s._capacity);

        }
        const char* c_str()const
        {
            return _str;
        }




        //capacity
       inline size_t size()const//元素个数
        {
            return _size;
        }
        inline size_t capacity()const//总容量
        {
            return _capacity;
        }
        inline bool empty()const//是否为空
        {
            return _size==0;
        }
        void resize(size_t n, char c = '\0')
        {
            if(n>_capacity)
            {
                reserve(n);
            }
            if(n>_size)
            {
                n-=_size;
                while(n--)
                {
                    _str[_size++] =c;
                }

                _str[_size+1]='\0';
            }
            else
            {
                _str[n]='\0';
            }

        }
        void reserve(size_t n)
        {
            if(n>=_capacity)
            {
                _str=(char*) realloc(_str,n+1);
            }
            _capacity=n+1;
        }



        //access
        char& operator[](size_t index)
        {
            assert(index<_size||index<0);

            return *_str;
        }
        const char& operator[](size_t index)const
        {
            assert(index>_size||index<0);
            cout<<_str[index];

              return *_str;
        }


        //relational operators
        bool operator<(const string& s)
        {
            int i=0;
            for( i=0;i<_size;i++)
            {
                if(_str[i]>=s._str[i])
                {
                    return false;
                }
            }
            if(_size>i)
            return false;
            if(s._size>i)
            return true;
        }
        bool operator>(const string& s)
        {
             return !(*this<s);
        }
        bool operator<=(const string& s)
        {

            int i=0;
            for( i=0;i<_size;i++)
            {
                if(_str[i]>s._str[i])
                {
                    return false;
                }
            }
            if(_size>i)
                return false;
            if(s._size>=i)
                return true;
        }

        bool operator>=(const string& s)
        {
           return !(*this<=s);
        }
        bool operator==(const string& s)
        {
            if(_size!=s._size)
                return false;
           Wxb:: string tmp(s.c_str());
           char *ch=tmp._str;
           char *ch2=_str;
            while(*ch2!='\0')
            {
                if(*ch2==*ch)
                {
                    ch2++;
                    ch++;
                }
                else
                {
                    return false;
                }
            }
            return true;

        }
        bool operator!=(const string& s)
        {
                  return !(*this==s);
        }



        // 返回c在string中第一次出现的位置
        size_t find (char c, size_t pos = 0) const
        {

            while(*_str!='\0')
            {
                if(*(_str+pos)==c)
                {
                    return pos;
                }
                pos++;
            }
            return -1;
        }
        // 返回子串s在string中第一次出现的位置
        size_t find (const char* s, size_t pos = 0) const
        {
              char *index= strstr(_str, s);
              return _str-index;
        }
        // 在pos位置上插入字符c/字符串str，并返回该字符的位置
        string& insert(size_t pos, char c)
        {
            if(_size>=_capacity-1)
            {
                reserve(_capacity*2);
            }

            int end=_size;
            while(end>=pos)
            {
                _str[end+1]=_str[end--];
            }
            _str[end]=c;
           _size++;

              return *this;
        }
        string& insert(size_t pos, const char* str)
        {

            int len=strlen(str);
            if(_size+len>=_capacity-1)
            {
                reserve(_capacity+len);
            }


            int end=_size+len-1;
            _size+=len;
            while(end>pos+len)
            {
                _str[end]=_str[end-len];
                end--;
            }
            while(len--)
            {
                _str[end--]=*(str+len);
            }

            return *this;

        }
        // 删除pos位置上的元素，并返回该元素的下一个位置
        string& erase(size_t pos, size_t len)
        {

            int begin=pos;


            while(begin<_size)
            {
                _str[begin]=_str[begin+len];
                begin++;
            }
            return *(this+pos+1);
        }


    private:
        int _size;
        int _capacity;
        char *_str;
    };
}